home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / disasm.tar / disasm / obj.c < prev    next >
C/C++ Source or Header  |  1990-04-25  |  9KB  |  556 lines
  1. #include "dis48.h"
  2.  
  3. #ifdef ANSI
  4. char    *Real(char *mem, NAddr *addr, char *out);
  5. char    *Complex(char *mem, NAddr *addr, char *out);
  6. char    *String(char *mem, NAddr *addr, char *out);
  7. char    *Array(char *mem, NAddr *addr, char *out);
  8. char    *List(char *mem, NAddr *addr, char *out);
  9. char    *GlobalName(char *mem, NAddr *addr, char *out);
  10. char    *LocalName(char *mem, NAddr *addr, char *out);
  11. char    *Program(char *mem, NAddr *addr, char *out);
  12. char    *Algebraic(char *mem, NAddr *addr, char *out);
  13. char    *BinaryInt(char *mem, NAddr *addr, char *out);
  14. char    *Graphic(char *mem, NAddr *addr, char *out);
  15. char    *Tagged(char *mem, NAddr *addr, char *out);
  16. char    *Unit(char *mem, NAddr *addr, char *out);
  17. char    *Xlib(char *mem, NAddr *addr, char *out);
  18. char    *Directory(char *mem, NAddr *addr, char *out);
  19. char    *Library(char *mem, NAddr *addr, char *out);
  20. char    *Backup(char *mem, NAddr *addr, char *out);
  21. char    *Command(char *mem, NAddr *addr, char *out);
  22. char    *Address(char *mem, NAddr *addr, char *out);
  23. char    *LongReal(char *mem, NAddr *addr, char *out);
  24. char    *LongComplex(char *mem, NAddr *addr, char *out);
  25. char    *LinkedArray(char *mem, NAddr *addr, char *out);
  26. char    *Character(char *mem, NAddr *addr, char *out);
  27. char    *Code(char *mem, NAddr *addr, char *out);
  28. char    *LibraryData(char *mem, NAddr *addr, char *out);
  29. #else
  30. char    *Real();
  31. char    *Complex();
  32. char    *String();
  33. char    *Array();
  34. char    *List();
  35. char    *GlobalName();
  36. char    *LocalName();
  37. char    *Program();
  38. char    *Algebraic();
  39. char    *BinaryInt();
  40. char    *Graphic();
  41. char    *Tagged();
  42. char    *Unit();
  43. char    *Xlib();
  44. char    *Directory();
  45. char    *Library();
  46. char    *Backup();
  47. char    *Command();
  48. char    *Address();
  49. char    *LongReal();
  50. char    *LongComplex();
  51. char    *LinkedArray();
  52. char    *Character();
  53. char    *Code();
  54. char    *LibraryData();
  55. #endif
  56.  
  57. struct objfunc {
  58.     NAddr    addr;
  59. #ifdef ANSI
  60.     char    *(*func)(char *mem, NAddr *addr, char *out);
  61. #else
  62.     char    *(*func)();
  63. #endif
  64. } objects[] = {
  65.     {0x02933, Real},
  66.     {0x02977, Complex},
  67.     {0x02a2c, String},
  68.     {0x029e8, Array},    /* Real */
  69.     {0x029e8, Array},    /* Complex */
  70.     {0x02a74, List},
  71.     {0x02e48, GlobalName},
  72.     {0x02e6d, LocalName},
  73.     {0x02d9d, Program},
  74.     {0x02ab8, Algebraic},
  75.     {0x02a4e, BinaryInt},
  76.     {0x02b1e, Graphic},
  77.     {0x02afc, Tagged},
  78.     {0x02ada, Unit},
  79.     {0x02e92, Xlib},
  80.     {0x02a96, Directory},
  81.     {0x02b40, Library},
  82.     {0x02b62, Backup},
  83.     {0x02e92, Command},    /* Function */
  84.     {0x02e92, Command},
  85.     {0x02911, Address},
  86.     {0x02955, LongReal},
  87.     {0x0299d, LongComplex},
  88.     {0x02a0a, LinkedArray},
  89.     {0x029bf, Character},
  90.     {0x02dcc, Code},
  91.     {0x02b88, LibraryData},
  92.     {0, NULL}
  93. };
  94.  
  95. NAddr
  96. #ifdef ANSI
  97. Object(char *mem, NAddr addr, char *out)
  98. #else
  99. Object(mem, addr, out)
  100. char    *mem;
  101. NAddr    addr;
  102. char    *out;
  103. #endif
  104. {
  105.     NAddr        n;
  106.     NAddr        a;
  107.     struct objfunc    *op;
  108.     
  109.     a = addr;
  110.     n = GetInt(mem, &a, 5);
  111.     for (op = objects; op->addr != 0; op++)
  112.         if (op->addr == n)
  113.             break;
  114.             
  115.     if (op->addr == 0) {
  116.         (void) AppendStr(out, "Unknown Object");
  117.         return(addr);
  118.     }
  119.     
  120.     (*op->func)(mem, &a, out);
  121.     return(a);
  122. }
  123.  
  124. char *
  125. #ifdef ANSI
  126. Number(char *mem, NAddr *addr, char *out, int fl, int xl)
  127. #else
  128. Number(mem, addr, out, fl, xl)
  129. char    *mem;
  130. NAddr    *addr;
  131. char    *out;
  132. int    fl;
  133. int    xl;
  134. #endif
  135. {
  136.     int    fi, xi;
  137.     Nybble    s, ip, xs;
  138.     Nybble    x[5];
  139.     Nybble    f[14];
  140.     
  141.     for (xi = 0; xi < xl; xi++)
  142.         x[xi] = GetNybble(mem, (*addr)++);
  143.         
  144.     xs = GetNybble(mem, (*addr)++);
  145.     
  146.     for (fi = 0; fi < fl; fi++)
  147.         f[fi] = GetNybble(mem, (*addr)++);
  148.         
  149.     ip = GetNybble(mem, (*addr)++);
  150.     s = GetNybble(mem, (*addr)++);
  151.     APPEND_CHAR(out, (s == 0) ? '+' : '-');
  152.     APPEND_CHAR(out, hex[ip]);
  153.     APPEND_CHAR(out, '.');
  154.     while (--fi >= 0)
  155.         APPEND_CHAR(out, hex[f[fi]]);
  156.     
  157.     APPEND_CHAR(out, 'E');
  158.     APPEND_CHAR(out, (xs == 0) ? '+' : '-');
  159.     while (--xi >= 0)
  160.         APPEND_CHAR(out, hex[x[xi]]);    
  161.         
  162.     TERMINATE(out);
  163.     return(out);
  164. }
  165.  
  166. char *
  167. #ifdef ANSI
  168. Real(char *mem, NAddr *addr, char *out)
  169. #else
  170. Real(mem, addr, out)
  171. char    *mem;
  172. NAddr    *addr;
  173. char    *out;
  174. #endif
  175. {
  176.     return(Number(mem, addr, out, 11, 2));
  177. }
  178.  
  179. char *
  180. #ifdef ANSI
  181. Complex(char *mem, NAddr *addr, char *out)
  182. #else
  183. Complex(mem, addr, out)
  184. char    *mem;
  185. NAddr    *addr;
  186. char    *out;
  187. #endif
  188. {
  189.     APPEND_CHAR(out, '(');
  190.     out = Number(mem, addr, out, 11, 2);
  191.     APPEND_COMMA(out);
  192.     out = Number(mem, addr, out, 11, 2);
  193.     APPEND_CHAR(out, ')');
  194.     return(out);
  195. }
  196.  
  197. char *
  198. #ifdef ANSI
  199. LongReal(char *mem, NAddr *addr, char *out)
  200. #else
  201. LongReal(mem, addr, out)
  202. char    *mem;
  203. NAddr    *addr;
  204. char    *out;
  205. #endif
  206. {
  207.     return(Number(mem, addr, out, 14, 4));
  208. }
  209.  
  210. char *
  211. #ifdef ANSI
  212. LongComplex(char *mem, NAddr *addr, char *out)
  213. #else
  214. LongComplex(mem, addr, out)
  215. char    *mem;
  216. NAddr    *addr;
  217. char    *out;
  218. #endif
  219. {
  220.     APPEND_CHAR(out, '(');
  221.     out = Number(mem, addr, out, 14, 4);
  222.     APPEND_COMMA(out);
  223.     out = Number(mem, addr, out, 14, 4);
  224.     APPEND_CHAR(out, ')');
  225.     return(out);
  226. }
  227.  
  228. char *
  229. #ifdef ANSI
  230. String(char *mem, NAddr *addr, char *out)
  231. #else
  232. String(mem, addr, out)
  233. char    *mem;
  234. NAddr    *addr;
  235. char    *out;
  236. #endif
  237. {
  238.     int    n;
  239.     int    lim;
  240.     char    c;
  241.     NAddr    a;
  242.     
  243.     n = GetInt(mem, addr, 5) - 5;
  244.     out = AppendStr(out, "String(");
  245.     out = AppendDecInt(out, n);
  246.     out = AppendStr(out, ") ");
  247.     lim = (n > 16) ? 16 : n;
  248.     a = *addr;
  249.     out = AppendHexNyb(out, mem, &a, lim);
  250.     if (lim < n)
  251.         out = AppendStr(out, "...");
  252.     
  253.     out = AppendStr(out, " \"");
  254.     lim /= 2;
  255.     a = *addr;
  256.     while (--lim >= 0) {
  257.         c = GetInt(mem, &a, 2);
  258.         if ((c < ' ') || (c > '~'))
  259.             c = '.';
  260.             
  261.         APPEND_CHAR(out, c);
  262.     }
  263.     
  264.     APPEND_CHAR(out, '"');
  265.     TERMINATE(out);
  266.     *addr += n;
  267.     return(out);
  268. }
  269.  
  270. char    *
  271. #ifdef ANSI
  272. Array(char *mem, NAddr *addr, char *out)
  273. #else
  274. Array(mem, addr, out)
  275. char    *mem;
  276. NAddr    *addr;
  277. char    *out;
  278. #endif
  279. {
  280.     return(out);
  281. }
  282.  
  283. char    *
  284. #ifdef ANSI
  285. List(char *mem, NAddr *addr, char *out)
  286. #else
  287. List(mem, addr, out)
  288. char    *mem;
  289. NAddr    *addr;
  290. char    *out;
  291. #endif
  292. {
  293.     return(out);
  294. }
  295.  
  296. char    *
  297. #ifdef ANSI
  298. GlobalName(char *mem, NAddr *addr, char *out)
  299. #else
  300. GlobalName(mem, addr, out)
  301. char    *mem;
  302. NAddr    *addr;
  303. char    *out;
  304. #endif
  305. {
  306.     return(out);
  307. }
  308.  
  309. char    *
  310. #ifdef ANSI
  311. LocalName(char *mem, NAddr *addr, char *out)
  312. #else
  313. LocalName(mem, addr, out)
  314. char    *mem;
  315. NAddr    *addr;
  316. char    *out;
  317. #endif
  318. {
  319.     return(out);
  320. }
  321.  
  322. char    *
  323. #ifdef ANSI
  324. Program(char *mem, NAddr *addr, char *out)
  325. #else
  326. Program(mem, addr, out)
  327. char    *mem;
  328. NAddr    *addr;
  329. char    *out;
  330. #endif
  331. {
  332.     return(out);
  333. }
  334.  
  335. char    *
  336. #ifdef ANSI
  337. Algebraic(char *mem, NAddr *addr, char *out)
  338. #else
  339. Algebraic(mem, addr, out)
  340. char    *mem;
  341. NAddr    *addr;
  342. char    *out;
  343. #endif
  344. {
  345.     return(out);
  346. }
  347.  
  348. char    *
  349. #ifdef ANSI
  350. BinaryInt(char *mem, NAddr *addr, char *out)
  351. #else
  352. BinaryInt(mem, addr, out)
  353. char    *mem;
  354. NAddr    *addr;
  355. char    *out;
  356. #endif
  357. {
  358.     int    n;
  359.     
  360.     out = AppendStr(out, "BinInt(");
  361.     n = GetInt(mem, addr, 5);
  362.     n -= 5;
  363.     out = AppendDecInt(out, n);
  364.     out = AppendStr(out, ") ");
  365.     out = AppendHexNyb(out, mem, addr, n);
  366.     TERMINATE(out);
  367.     return(out);
  368. }
  369.  
  370. char *
  371. #ifdef ANSI
  372. Graphic(char *mem, NAddr *addr, char *out)
  373. #else
  374. Graphic(mem, addr, out)
  375. char    *mem;
  376. NAddr    *addr;
  377. char    *out;
  378. #endif
  379. {
  380.     return(out);
  381. }
  382.  
  383. char *
  384. #ifdef ANSI
  385. Tagged(char *mem, NAddr *addr, char *out)
  386. #else
  387. Tagged(mem, addr, out)
  388. char    *mem;
  389. NAddr    *addr;
  390. char    *out;
  391. #endif
  392. {
  393.     return(out);
  394. }
  395.  
  396. char *
  397. #ifdef ANSI
  398. Unit(char *mem, NAddr *addr, char *out)
  399. #else
  400. Unit(mem, addr, out)
  401. char    *mem;
  402. NAddr    *addr;
  403. char    *out;
  404. #endif
  405. {
  406.     return(out);
  407. }
  408.  
  409. char *
  410. #ifdef ANSI
  411. Xlib(char *mem, NAddr *addr, char *out)
  412. #else
  413. Xlib(mem, addr, out)
  414. char    *mem;
  415. NAddr    *addr;
  416. char    *out;
  417. #endif
  418. {
  419.     return(out);
  420. }
  421.  
  422. char *
  423. #ifdef ANSI
  424. Directory(char *mem, NAddr *addr, char *out)
  425. #else
  426. Directory(mem, addr, out)
  427. char    *mem;
  428. NAddr    *addr;
  429. char    *out;
  430. #endif
  431. {
  432.     return(out);
  433. }
  434.  
  435. char *
  436. #ifdef ANSI
  437. Library(char *mem, NAddr *addr, char *out)
  438. #else
  439. Library(mem, addr, out)
  440. char    *mem;
  441. NAddr    *addr;
  442. char    *out;
  443. #endif
  444. {
  445.     return(out);
  446. }
  447.  
  448. char *
  449. #ifdef ANSI
  450. Backup(char *mem, NAddr *addr, char *out)
  451. #else
  452. Backup(mem, addr, out)
  453. char    *mem;
  454. NAddr    *addr;
  455. char    *out;
  456. #endif
  457. {
  458.     return(out);
  459. }
  460.  
  461. char *
  462. #ifdef ANSI
  463. Command(char *mem, NAddr *addr, char *out)
  464. #else
  465. Command(mem, addr, out)
  466. char    *mem;
  467. NAddr    *addr;
  468. char    *out;
  469. #endif
  470. {
  471.     return(out);
  472. }
  473.  
  474.  
  475. char    *
  476. #ifdef ANSI
  477. Address(char *mem, NAddr *addr, char *out)
  478. #else
  479. Address(mem, addr, out)
  480. char    *mem;
  481. NAddr    *addr;
  482. char    *out;
  483. #endif
  484. {
  485.     out = AppendStr(out, "Address(5) ");
  486.     out = AppendHexNyb(out, mem, addr, 5);
  487.     TERMINATE(out);
  488.     return(out);
  489. }
  490.  
  491. char    *
  492. #ifdef ANSI
  493. LinkedArray(char *mem, NAddr *addr, char *out)
  494. #else
  495. LinkedArray(mem, addr, out)
  496. char    *mem;
  497. NAddr    *addr;
  498. char    *out;
  499. #endif
  500. {
  501.     return(out);
  502. }
  503.  
  504. char    *
  505. #ifdef ANSI
  506. Character(char *mem, NAddr *addr, char *out)
  507. #else
  508. Character(mem, addr, out)
  509. char    *mem;
  510. NAddr    *addr;
  511. char    *out;
  512. #endif
  513. {
  514.     int    c;
  515.     NAddr    a;
  516.     
  517.     out = AppendStr(out, "Character(2) ");
  518.     a = *addr;
  519.     out = AppendHexNyb(out, mem, addr, 2);
  520.     out = AppendStr(out, " '");
  521.     c = GetInt(mem, &a, 2);
  522.     if ((c < ' ') || (c > '~'))
  523.         c = '.';
  524.     
  525.     APPEND_CHAR(out, c);
  526.     APPEND_CHAR(out, '\'');
  527.     TERMINATE(out);
  528.     return(out);
  529. }
  530.  
  531. char    *
  532. #ifdef ANSI
  533. Code(char *mem, NAddr *addr, char *out)
  534. #else
  535. Code(mem, addr, out)
  536. char    *mem;
  537. NAddr    *addr;
  538. char    *out;
  539. #endif
  540. {
  541.     return(out);
  542. }
  543.  
  544. char    *
  545. #ifdef ANSI
  546. LibraryData(char *mem, NAddr *addr, char *out)
  547. #else
  548. LibraryData(mem, addr, out)
  549. char    *mem;
  550. NAddr    *addr;
  551. char    *out;
  552. #endif
  553. {
  554.     return(out);
  555. }
  556.